/*
 * StructureDTD.cpp
 *
 *  Created on: 22 mars 2011
 *      Author: lgu
 */

using namespace std;
#include <iostream>
#include "StructureDTD.h"




DTDEntite::DTDEntite()
{

}

DTDEntite::~DTDEntite()
{

}


bool DTDEntite::isElement()
{
	DTDElement* pEl;
	pEl = dynamic_cast<DTDElement*>(this);
	if (pEl == 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

bool DTDEntite::isEnsemble()
{
	DTDEnsemble* pEn;
	pEn = dynamic_cast<DTDEnsemble*>(this);
	if (pEn == 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

string DTDEntite::getAffichage()
{
	return "<vide>";
}


DTDElement::DTDElement() : DTDEntite()
{

}

DTDElement::DTDElement(string unNom) : DTDEntite()
{
	name = unNom;
}

DTDElement::~DTDElement()
{

}

string DTDElement::getName()
{
	return name;
}


string DTDElement::getAffichage()
{
	return name;
}

//-----------------------------------------------------

DTDEnsemble::DTDEnsemble() : DTDEntite()
{
	sousEntites.reserve(100);
	relations.reserve(100);
}

DTDEnsemble::DTDEnsemble(const vector<AppEntite>& listeSE, const vector<int>& relationSE) : DTDEntite()
{
	sousEntites = listeSE;
	relations = relationSE;
}

DTDEnsemble::~DTDEnsemble()
{

}

void DTDEnsemble::ajouterEntite(AppEntite unSE, int relation)
{
	sousEntites.push_back(unSE);
	relations.push_back(relation);
}

vector<AppEntite> DTDEnsemble::getEntites()
{
	return sousEntites;
}

vector<int> DTDEnsemble::getRelations()
{
	return relations;
}

string DTDEnsemble::getAffichage()
{
	string strAffiche = "(";
	int i;
	for (i = 0; i < (int) relations.size(); i++)
	{
		strAffiche = strAffiche + sousEntites.at(i).getAffichage();
		if (relations.at(i)==0)
		{
			strAffiche = strAffiche + " ";
		}
		else
		if (relations.at(i)==1)
		{
			strAffiche = strAffiche + ",";
		}
		else
		if (relations.at(i)==2)
		{
			strAffiche = strAffiche + "|";
		}

	}
	strAffiche = strAffiche + sousEntites.at(relations.size()).getAffichage();
	strAffiche = strAffiche + ")";
	return strAffiche;
}

//------------------------------------------------------------

AppEntite::AppEntite()
{

}

AppEntite::AppEntite(DTDEntite* unEntite, int unCard)
{
	if (unEntite->isElement())
	{
		DTDElement* pEl = dynamic_cast<DTDElement*>(unEntite);
		string nom =pEl->getName();
		contenuAppEntite = new DTDElement(nom);
	}
	else
	if (unEntite->isEnsemble())
	{
		DTDEnsemble* pEn = dynamic_cast<DTDEnsemble*>(unEntite);
		vector<AppEntite> listeSE = pEn->getEntites();
		vector<int> listeRE = pEn->getRelations();
		contenuAppEntite = new DTDEnsemble(listeSE, listeRE);
	}
	typeCardinalite = unCard;
}

string AppEntite::getAffichage()
{
	string str;
	if (contenuAppEntite->isElement())
	{
		DTDElement* pEl = dynamic_cast<DTDElement*>(contenuAppEntite);
		str = pEl->getAffichage();
	}
	else
	if (contenuAppEntite->isEnsemble())
	{
		DTDEnsemble* pEn = dynamic_cast<DTDEnsemble*>(contenuAppEntite);
		str = pEn->getAffichage();
	}

	if (typeCardinalite == 0)
	{
		str = str;
	}
	else
	if (typeCardinalite == 1)
	{
		str = str + "+";
	}
	else
	if (typeCardinalite == 2)
	{
		str = str + "*";
	}
	else
	if (typeCardinalite == 3)
	{
		str = str + "?";
	}

	return str;
}

//============================================
DTDPhrase::DTDPhrase()
{

}

DTDPhrase::~DTDPhrase()
{

}

bool DTDPhrase::isElement()
{
	DTDPhraseElement* pPE;
	pPE = dynamic_cast<DTDPhraseElement*>(this);
	if (pPE == 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

bool DTDPhrase::isAttlist()
{
	DTDPhraseAttlist* pPA;
	pPA = dynamic_cast<DTDPhraseAttlist*>(this);
	if (pPA == 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}


//=========================================

DTDPhraseElement::DTDPhraseElement() : DTDPhrase()
{

}

DTDPhraseElement::DTDPhraseElement(DTDElement unEle, int type) : DTDPhrase()
{
	elementCorr = unEle;
	typeRelationCorr = type;
}


DTDPhraseElement::~DTDPhraseElement()
{

}

bool DTDPhraseElement::ajouterEnsemble(DTDEnsemble unEnsem, int unCard)
{
	if (typeRelationCorr!=0)
	{
		return false;
	}
	else
	{
		ensembleCorr= AppEntite(&unEnsem, unCard);
	}
	return true;
}

bool DTDPhraseElement::ajouterEnsemble(AppEntite ent)
{
  if (typeRelationCorr != 0)
    return false;
  else
    ensembleCorr = ent;
}

string DTDPhraseElement::getAffichage()
{
	string str ="<!ELEMENT "+elementCorr.getAffichage()+" ";
	if (typeRelationCorr == 0)
	{
		str = str + ensembleCorr.getAffichage()+">";
	}
	else
	if (typeRelationCorr == 1)
	{
		str = str + "EMPTY>";
	}
	else
	if (typeRelationCorr == 2)
	{
		str = str + "ANY>";
	}
	else
	if (typeRelationCorr == 3)
	{
		str = str + "(#PCDATA)>";
	}
	else
	if (typeRelationCorr == 4)
	{
		str = str + "(#CDATA)>";
	}

	return str;
}


//======================================================

DTDPhraseAttlist::DTDPhraseAttlist() : DTDPhrase()
{

}

DTDPhraseAttlist::DTDPhraseAttlist(const string& nomE) : DTDPhrase(), nomElem(nomE)
{
}

DTDPhraseAttlist::~DTDPhraseAttlist()
{

}

void DTDPhraseAttlist::addAttribute(const DTDAttribute& attr)
{
    attributes.push_back(attr);
}

string DTDPhraseAttlist::getAffichage()
{
	string str = "<!ATTLIST " + nomElem + " ";
	
	for (vector<DTDAttribute>::const_iterator it = attributes.begin(); it != attributes.end(); it++) {
	    str += it->getAffichage();
	    if (it != attributes.end() - 1)
	      str += "\n";
	}

	str = str + ">";

	return str;
}


StructureEntiteDTD::StructureEntiteDTD()
{
	contenu.reserve(100);
}


void StructureEntiteDTD::ajouterPhrase(DTDPhrase* unContenu)
{
	if (unContenu->isElement())
	{
		DTDPhraseElement* pPE = dynamic_cast<DTDPhraseElement*>(unContenu);
		contenu.push_back(pPE);
	}
	else
	if (unContenu->isAttlist())
	{
		DTDPhraseAttlist* pPA = dynamic_cast<DTDPhraseAttlist*>(unContenu);
		contenu.push_back(pPA);
	}

}

string StructureEntiteDTD::getAffichage()
{
  string ret = "";
  for (unsigned int i=0; i<contenu.size(); i++)
  {
	  ret += contenu[i]->getAffichage() + "\n";
  }

  return ret;
}
// vector<string> StructureEntiteDTD::getAffichage()
// {
// 	vector<string> vecStr;
// 	for (unsigned int i=0; i<=contenu.size()-1; i++)
// 	{
// 		if (contenu.at(i)->isElement())
// 		{
// 			DTDPhraseElement* pPE = dynamic_cast<DTDPhraseElement*>(contenu.at(i));
// 			vecStr.push_back(pPE->getAffichage());
// 		}
// 		else
// 		if (contenu.at(i)->isAttlist())
// 		{
// 			DTDPhraseAttlist* pPA = dynamic_cast<DTDPhraseAttlist*>(contenu.at(i));
// 			vecStr.push_back(pPA->getAffichage());
// 		}
// 
// 	}
// 
// 	return vecStr;
// }

// int main()
// {
// 	DTDElement doc("doc");
// 	DTDElement auteur("auteur");
// 	DTDElement chapitre("chapitre");
// 	DTDElement paragraphe("paragraphe");
// 
// 	cout << "1" << endl;
// 	cout << chapitre.getAffichage() << endl;
// 
// 	AppEntite appAuteur(&auteur, 0);
// 	AppEntite appChapitre(&chapitre, 2);
// 	AppEntite appParagraphe(&paragraphe, 1);
// 
// 	cout << "2" << endl;
// 	cout << appChapitre.getAffichage() << endl;
// 
// 
// 	vector<AppEntite> vectEntite;
// 	vectEntite.push_back(appAuteur);
// 	vectEntite.push_back(appChapitre);
// 	vectEntite.push_back(appParagraphe);
// 
// 	cout << "3" << endl;
// 
// 	vector<int> vectRelation;
// 	vectRelation.push_back(1);
// 	vectRelation.push_back(1);
// 
// 	cout << "4" << endl;
// 
// 
// 	DTDEnsemble ensemble1(vectEntite, vectRelation);
// 
// 	cout << "5" << endl;
// 	cout << ensemble1.getAffichage() << endl;
// 
// 	DTDPhraseElement DTDPhEle(doc, 0);
// 	DTDPhEle.ajouterEnsemble(ensemble1,1);
// 
// 	cout << "6" << endl;
// 
// 	for (unsigned int i=0; i<=vectEntite.size()-1;i++)
// 	{
// 		cout << vectEntite.at(i).getAffichage() << " ";
// 	}
// 	cout << endl;
// 
// 	cout << "7" << endl;
// 
// 	cout << DTDPhEle.getAffichage() << endl;
// 
// 
// 	DTDPhraseAttlist DTDPhAtt("chapitre", "titre", "CDATA", 1);
// 
// 	cout << "8" << endl;
// 	cout << DTDPhAtt.getAffichage() << endl;
// 
// 	StructureEntiteDTD sDTD;
// 	sDTD.ajouterPhrase(&DTDPhAtt);
// 	sDTD.ajouterPhrase(&DTDPhEle);
// 	cout << sDTD.getAffichage() << endl;
// 	
// 	//Test d'éléments imbriqués
// 	//<!ELEMENT chapitre (titre, (p | section)+)>
// 	DTDElement chap("chapitre");
// 	DTDElement tit("titre");
// 	DTDElement p("p");
// 	DTDElement sec("section");
// 	
// 	vector<AppEntite> vectEnt;
// 	vectEnt.push_back(AppEntite(&p, 0));
// 	vectEnt.push_back(AppEntite(&sec, 0));
// 	
// 	vector<int> vect2;
// 	vect2.push_back(2);
// 	
// 	DTDEnsemble ens(vectEnt, vect2);
// 	cout << ens.getAffichage() << endl;
// 	
// 	vectEnt.clear();
// 	vectEnt.push_back(AppEntite(&tit, 0));
// 	vectEnt.push_back(AppEntite(&ens, 1));
// 	vect2.clear();
// 	vect2.push_back(1);
// 	DTDEnsemble ens2(vectEnt, vect2);
// 	cout << ens2.getAffichage() << endl;
// 	
// 	DTDPhraseElement dtdph(chapitre, 0);
// 	dtdph.ajouterEnsemble(ens2);
// 	cout << dtdph.getAffichage() << endl;
// 
// 	//<!ELEMENT chapitre (#PCDATA)>
// 	
// 	return 0;
// } 
